package com.googlecode.lemyriapode.regle;

import com.googlecode.lemyriapode.type.Echiquier;
import static com.googlecode.lemyriapode.type.Echiquier.*;
import static com.googlecode.lemyriapode.type.Echiquier.Case.*;
import static com.googlecode.lemyriapode.regle.Position.Piece.*;
import com.googlecode.lemyriapode.type.Echiquier.Direction;
import java.util.HashMap;
import java.util.Map;

/**
 * Définition d'une position au jeu d'échecs
 * L'entrée de main()
 * @author Gilles
 */
public class Position {

    final static boolean trait_aux_blancs = true;
    final static boolean trait_aux_noirs = false;
    final static boolean blanc = true;
    final static boolean noir = false;
    private boolean trait;
    private Map<Case, Piece> _PositionCourante;
    private Echiquier _Echiquier;

    /**
     * Les Pieces :
     * Couleur,règle de leur mouvement, n_case(true) ou 1_case
     */
    public enum Piece {

        tour_b(blanc, getHV(), true),
        tour_n(noir, getHV(), true),
        cavalier_b(blanc, getCavalier(), false),
        cavalier_n(noir, getCavalier(), false),
        fou_b(blanc, getD(), true),
        fou_n(noir, getD(), true),
        dame_b(blanc, getHVD(), true),
        dame_n(noir, getHVD(), true),
        roi_b(blanc, getHVD(), false),
        roi_n(noir, getHVD(), false),
        pion_b(blanc, getPion(), false),
        pion_n(noir, getPion(), false);
        private boolean Couleur;
        private Direction[] _Regle_deplacement;
        private boolean _NCase;

        private Piece(boolean couleur, Direction[] R_Mouvt, boolean NCase) {
            Couleur = couleur;
            _Regle_deplacement = R_Mouvt;
            _NCase = NCase;
        }

        /**
         * @return the Couleur
         */
        public boolean isCouleur() {
            return Couleur;
        }

        /**
         * @return the _Regle_deplacement
         */
        public Direction[] getRegle_deplacement() {
            return _Regle_deplacement;
        }

        /**
         * @return the _NCase
         */
        public boolean isNCase() {
            return _NCase;
        }
    }

    /**
     * Echiquier _PositionCourante
     */
    public Position() {
        trait = trait_aux_blancs;
        _Echiquier = new Echiquier();
        _PositionCourante = new HashMap<Case, Piece>(64);
        ////
        _PositionCourante.put(a1, tour_b);
//        _PositionCourante.put(b1, cavalier_b);
        _PositionCourante.put(c1, fou_b);
        _PositionCourante.put(d1, dame_b);
        _PositionCourante.put(e1, roi_b);
        _PositionCourante.put(f1, fou_b);
//        _PositionCourante.put(g1, cavalier_b);
        _PositionCourante.put(h1, tour_b);

    }

    public Position(Case _case, Direction dir) {
        _Echiquier = new Echiquier(_case, dir);

    }

    public Piece getPiece(Case _c) {
        return _PositionCourante.get(_c);

    }

    /**
     * @return the trait
     */
    public boolean isTrait() {
        return trait;
    }

    /**
     * @return the _PositionCourante
     */
    public Map<Case, Piece> getPositionCourante() {
        return _PositionCourante;
    }

    /**
     * @return the _Echiquier
     */
    public Echiquier getEchiquier() {
        return _Echiquier;
    }
}
